home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 April: Mac OS SDK / Dev.CD Apr 98 SDK1.toast / Development Kits (Disc 1) / QuickDraw 3D / Windows files / Q3WinSDK.exe / QD3DSDK / Samples / Win32Sample / 3DShell.c next >
Encoding:
C/C++ Source or Header  |  1996-12-20  |  35.7 KB  |  1,112 lines
  1. #include <windows.h>        // required for all Windows applications
  2. #include "resource.h"        // Windows resource IDs
  3. #include "3dshell.h"        // specific to this program
  4. #include <stdio.h>
  5.  
  6. #include "Box3DSupport.h"
  7.  
  8. HINSTANCE hInst;              // current instance
  9.  
  10. DocumentPtr        gDocument = NULL;
  11.  
  12. char szAppName[] = "QuickDraw 3D Demo";        // The name of this application
  13. char szTitle[]   = "QuickDraw 3D Demo";        // The title bar text
  14. COLORREF customColors[16] = { 0L };            // for use by choosecolor dialog
  15.  
  16. typedef enum tStorageMethod
  17. {
  18.     kStorageUnixFile,
  19.     kStorageUnixPath,
  20.     kStorageWin32Handle,
  21.     kStorageWin32MMFile
  22. } tStorageMethod;
  23.  
  24. void        OpenModelFile( tStorageMethod );
  25. void        SaveModelFile( tStorageMethod storageMethod, TQ3FileMode dstFileMode );
  26.  
  27. TQ3Status    BrowseForPathName(char *inPathName, BOOLEAN fOpen);
  28.  
  29. void        UpdateFrame(BOOLEAN step);
  30.  
  31. BOOL        InitDocumentData( DocumentPtr theDocument, HWND inWindow );
  32. void        DisposeDocumentData( DocumentPtr theDocument);
  33. void        DisposeRenderingData( DocumentPtr theDocument);
  34. TQ3Status    DocumentDraw3DData( DocumentPtr theDocument );
  35. int            Speedometer_ClockFrame( void );
  36.  
  37. TQ3Status    DocumentNewWindowSize(DocumentPtr theDocument, unsigned long width, unsigned long height);
  38.  
  39. TQ3Status    PaintDocumentWindow(DocumentPtr theDocument);
  40.  
  41. TQ3Status    GetToolBarPosition(DocumentPtr theDocument, unsigned long *x, unsigned long *y);
  42. TQ3Status    GetToolBarSize(DocumentPtr theDocument, unsigned long *width, unsigned long *height);
  43.  
  44. void        InitQD3DMenu ( HWND hwnd );
  45.  
  46. void        MyErrorHandler(TQ3Error firstError, TQ3Error lastError, long refCon); 
  47.  
  48. #define REFERROR 00L
  49. #define REFWARNING 01L
  50. #define REFNOTICE 02L
  51.  
  52. static void StartTimer( void );
  53. static void StopTimer( void );
  54.  
  55. VOID CALLBACK TimerProc( HWND, UINT, UINT, DWORD );    
  56. UINT gTimer;
  57. #define MILLSPERTICK 10  // milliseconds per timer tick
  58.  
  59.  
  60. int CALLBACK WinMain(
  61.         HINSTANCE hInstance,
  62.         HINSTANCE hPrevInstance,
  63.         LPSTR lpCmdLine,
  64.         int nCmdShow)
  65. {
  66.         MSG msg;
  67.         HANDLE hAccelTable;
  68.  
  69.         if (!InitApplication(hInstance)) 
  70.         {
  71.             return (FALSE);    
  72.         }
  73.  
  74.         if (!InitInstance(hInstance, nCmdShow)) 
  75.         {
  76.             return (FALSE);
  77.         }
  78.  
  79.         hAccelTable = LoadAccelerators (hInstance, MAKEINTRESOURCE(IDR_GENERIC));
  80.  
  81.         StartTimer();
  82.         while (GetMessage(&msg, NULL, 0, 0)) {
  83.             if (!TranslateAccelerator (msg.hwnd, hAccelTable, &msg)) {
  84.                 TranslateMessage(&msg);
  85.                 DispatchMessage(&msg);
  86.             }
  87.         }
  88.         StopTimer();
  89.  
  90.         return (msg.wParam); // Returns the value from PostQuitMessage
  91. }
  92.  
  93. void UpdateFrame(BOOLEAN step)
  94. {
  95.     TQ3Matrix4x4    tmp;
  96.     RECT            aWinRect;
  97.     BOOL            aResult;
  98.     if( step )
  99.     {
  100.         Q3Matrix4x4_SetRotate_XYZ(&tmp, 0.05F, 0.05F, 0.05F);
  101.         Q3Matrix4x4_Multiply(&gDocument->fRotation, &tmp, &gDocument->fRotation);
  102.     }
  103.     aResult = GetClientRect(gDocument->fWindow, (LPRECT)&aWinRect);
  104.     aWinRect.bottom = aWinRect.top + gDocument->fHeight;
  105.     aResult = InvalidateRect(gDocument->fWindow, &aWinRect, FALSE);    
  106. }
  107.  
  108.  
  109. BOOL InitApplication(HINSTANCE hInstance)
  110. {
  111.         WNDCLASS  wc;
  112.  
  113.         wc.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;    /* CS_OWNDC is required to support the Win32DC Draw context */
  114.         wc.lpfnWndProc   = (WNDPROC)WndProc;       
  115.         wc.cbClsExtra    = 0;                      
  116.         wc.cbWndExtra    = 0;                     
  117.         wc.hInstance     = hInstance;             
  118.         wc.hIcon         = LoadIcon (hInstance, MAKEINTRESOURCE(IDI_APP)); 
  119.         wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
  120.         wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  121.         wc.lpszMenuName  = MAKEINTRESOURCE(IDR_GENERIC); 
  122.         wc.lpszClassName = szAppName;              
  123.  
  124.         return (RegisterClass(&wc));
  125. }
  126.  
  127. BOOL InitInstance(
  128.         HINSTANCE       hInstance,
  129.         int             nCmdShow)
  130. {
  131.         HWND            hWnd; 
  132.  
  133.         hInst = hInstance; 
  134.         hWnd = CreateWindowEx(
  135.                 WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE,
  136.                 szAppName,          
  137.                 szTitle,             
  138.                 WS_OVERLAPPEDWINDOW, 
  139.                 25, 25, 640, 530,      // fixed size windows
  140.                 NULL,                
  141.                 NULL,                
  142.                 hInstance,           
  143.                 NULL                 
  144.         );
  145.  
  146.         if (!hWnd) 
  147.         {
  148.             return (FALSE);
  149.         }
  150.  
  151.  
  152.         ShowWindow(hWnd, nCmdShow); 
  153.         UpdateWindow(hWnd);        
  154.  
  155.         return (TRUE);             
  156.  
  157. }
  158.  
  159. static void StartTimer( void )
  160. {
  161.     if( gDocument && kQ3True == gDocument->spin)
  162.         gTimer = SetTimer( NULL, 0, MILLSPERTICK, (TIMERPROC) TimerProc );
  163. }
  164.  
  165. static void StopTimer( void )
  166. {
  167.     if( gDocument && kQ3True == gDocument->spin)
  168.         KillTimer( NULL, gTimer );
  169. }
  170.  
  171. VOID CALLBACK TimerProc(
  172.     HWND hwnd,    // handle of window for timer messages 
  173.     UINT uMsg,    // WM_TIMER message
  174.     UINT idEvent,    // timer identifier
  175.     DWORD dwTime     // current system time
  176.    )    
  177. {
  178.     if( kQ3True == gDocument->spin)
  179.         UpdateFrame(TRUE);
  180. }
  181.  
  182.  
  183. LRESULT CALLBACK WndProc(
  184.                 HWND hWnd,        
  185.                 UINT message,      
  186.                 WPARAM uParam,     
  187.                 LPARAM lParam)   
  188. {
  189.         int wmId, wmEvent;
  190.         TQ3Status    aStatus;
  191.         PAINTSTRUCT PaintStruct;
  192.  
  193.         switch (message) 
  194.         {
  195.             case WM_COMMAND:
  196.  
  197.                 wmId    = LOWORD(uParam);
  198.                 wmEvent = HIWORD(uParam);
  199.  
  200.                 switch (wmId) 
  201.                 {
  202.                     case IDM_ABOUT:
  203.                         StopTimer();
  204.                         DialogBox(hInst,          
  205.                                 MAKEINTRESOURCE(IDD_ABOUTBOX),
  206.                                 hWnd,                 
  207.                                 (DLGPROC)About);
  208.                         StartTimer();
  209.                         break;
  210.                     case ID_FILE_OPEN_WIN32:
  211.                         StopTimer();
  212.                         OpenModelFile(kStorageWin32Handle);
  213.                         StartTimer();
  214.                         break;
  215.                     case ID_FILE_OPEN_MMF:
  216.                         StopTimer();
  217.                         OpenModelFile(kStorageWin32MMFile);
  218.                         StartTimer();
  219.                         break;
  220.                     case ID_FILE_OPEN_UNIX:
  221.                         StopTimer();
  222.                         OpenModelFile(kStorageUnixFile);
  223.                         StartTimer();
  224.                         break;
  225.                     case ID_FILE_OPEN_PATH:
  226.                         StopTimer();
  227.                         OpenModelFile(kStorageUnixPath);
  228.                         StartTimer();
  229.                         break;
  230.                     case ID_FILE_SAVE_WIN32:
  231.                         StopTimer();
  232.                         SaveModelFile(kStorageWin32Handle, kQ3FileModeNormal );
  233.                         StartTimer();
  234.                         break;
  235.                     case ID_FILE_SAVE_WIN32_TEXT:
  236.                         StopTimer();
  237.                         SaveModelFile(kStorageWin32Handle, kQ3FileModeText );
  238.                         StartTimer();
  239.                         break;
  240.                     case ID_FILE_SAVE_UNIX:
  241.                         StopTimer();
  242.                         SaveModelFile(kStorageUnixFile, kQ3FileModeNormal );
  243.                         StartTimer();
  244.                         break;
  245.                     case ID_FILE_SAVE_UNIX_TEXT:
  246.                         StopTimer();
  247.                         SaveModelFile(kStorageUnixFile, kQ3FileModeText );
  248.                         StartTimer();
  249.                         break;
  250.                     case ID_FILE_SAVE_PATH:
  251.                         StopTimer();
  252.                         SaveModelFile(kStorageUnixPath, kQ3FileModeNormal );
  253.                         StartTimer();
  254.                         break;
  255.                     case ID_FILE_SAVE_PATH_TEXT:
  256.                         StopTimer();
  257.                         SaveModelFile(kStorageUnixPath, kQ3FileModeText );
  258.                         StartTimer();
  259.                         break;
  260.  
  261.                     case IDM_EXIT:
  262.                         DestroyWindow (hWnd);
  263.                         break;
  264.  
  265.                     case ID_QD3D_RENDERER_INTERACTIVE:
  266.                         if( kQ3RendererTypeInteractive != gDocument->rendererType)
  267.                         {
  268.                             gDocument->rendererType = kQ3RendererTypeInteractive;
  269.                             DisposeRenderingData( gDocument);
  270.                             InitDocumentData( gDocument, hWnd ); 
  271.                             UpdateFrame((BOOLEAN)(kQ3True == gDocument->spin));    
  272.                         }
  273.                         break;
  274.                     
  275.                     case ID_QD3D_RENDERER_WIREFRAME:
  276.                         if( kQ3RendererTypeWireFrame != gDocument->rendererType)
  277.                         {
  278.                             gDocument->rendererType = kQ3RendererTypeWireFrame;
  279.                             DisposeRenderingData( gDocument);
  280.                             InitDocumentData( gDocument, hWnd ); 
  281.                             UpdateFrame((BOOLEAN)(kQ3True == gDocument->spin));    
  282.                         }
  283.                         break;
  284.                     
  285.                     case ID_QD3D_DRAWCONTEXT_WIN32DC:
  286.                         if( kQ3DrawContextTypeWin32DC != gDocument->drawcontextType)
  287.                         {
  288.                             gDocument->drawcontextType = kQ3DrawContextTypeWin32DC;
  289.                             DisposeRenderingData( gDocument);
  290.                             InitDocumentData( gDocument, hWnd ); 
  291.                             UpdateFrame((BOOLEAN)(kQ3True == gDocument->spin));    
  292.                         }
  293.                         break;
  294.  
  295.                     case ID_QD3D_DRAWCONTEXT_PIXMAP16BIT555:
  296.                         if(!( kQ3DrawContextTypePixmap == gDocument->drawcontextType 
  297.                             && kQ3PixelTypeRGB16 == gDocument->fPixelFormat ))
  298.                         {
  299.                             gDocument->drawcontextType = kQ3DrawContextTypePixmap;
  300.                             gDocument->fPixelFormat = kQ3PixelTypeRGB16;
  301.                             DisposeRenderingData( gDocument);
  302.                             InitDocumentData( gDocument, hWnd ); 
  303.                             UpdateFrame((BOOLEAN)(kQ3True == gDocument->spin));    
  304.                         }
  305.                         break;
  306.                     
  307.                     case ID_QD3D_DRAWCONTEXT_PIXMAP16BIT565:
  308.                         if(!( kQ3DrawContextTypePixmap == gDocument->drawcontextType 
  309.                             && kQ3PixelTypeRGB16_565 == gDocument->fPixelFormat ))
  310.                         {
  311.                             gDocument->drawcontextType = kQ3DrawContextTypePixmap;
  312.                             gDocument->fPixelFormat = kQ3PixelTypeRGB16_565;
  313.                             DisposeRenderingData( gDocument);
  314.                             InitDocumentData( gDocument, hWnd ); 
  315.                             UpdateFrame((BOOLEAN)(kQ3True == gDocument->spin));    
  316.                         }
  317.                         break;
  318.  
  319.                     case ID_QD3D_DRAWCONTEXT_PIXMAP24BIT:
  320.                         if( !(kQ3DrawContextTypePixmap == gDocument->drawcontextType 
  321.                             && kQ3PixelTypeRGB24 == gDocument->fPixelFormat ))
  322.                         {
  323.                             gDocument->drawcontextType = kQ3DrawContextTypePixmap;
  324.                             gDocument->fPixelFormat = kQ3PixelTypeRGB24;
  325.                             DisposeRenderingData( gDocument);
  326.                             InitDocumentData( gDocument, hWnd ); 
  327.                             UpdateFrame((BOOLEAN)(kQ3True == gDocument->spin));    
  328.                         }
  329.                         break;
  330.                     
  331.                     case ID_QD3D_DRAWCONTEXT_PIXMAP32BIT:
  332.                         if( !(kQ3DrawContextTypePixmap == gDocument->drawcontextType 
  333.                             && kQ3PixelTypeRGB32 == gDocument->fPixelFormat ) )
  334.                         {
  335.                             gDocument->drawcontextType = kQ3DrawContextTypePixmap;
  336.                             gDocument->fPixelFormat = kQ3PixelTypeRGB32;
  337.                             DisposeRenderingData( gDocument);
  338.                             InitDocumentData( gDocument, hWnd ); 
  339.                             UpdateFrame((BOOLEAN)(kQ3True == gDocument->spin));    
  340.                         }
  341.                         break;
  342.  
  343.                     case ID_QD3D_SPIN:
  344.                         if( kQ3True == gDocument->spin)
  345.                         {
  346.                             gDocument->spin = kQ3False;
  347.                             StopTimer();
  348.                         }
  349.                         else
  350.                         {
  351.                             gDocument->spin = kQ3True;
  352.                             StartTimer();
  353.                         }
  354.                         break;
  355.                     
  356.                     case ID_QD3D_STEP:
  357.                         if( kQ3True == gDocument->spin)
  358.                         {
  359.                             gDocument->spin = kQ3False;
  360.                             StopTimer();
  361.                         }
  362.                         UpdateFrame(TRUE);    
  363.                         break;
  364.                     
  365.                     case ID_QD3D_CLEARCOLOR:
  366.                         {
  367.                         CHOOSECOLOR cc;
  368.                         memset(&cc,0,sizeof( CHOOSECOLOR ) ); 
  369.                         cc.lStructSize = sizeof( CHOOSECOLOR ); 
  370.                         cc.hwndOwner = hWnd; 
  371.                         cc.hInstance = hInst; 
  372.                         cc.lpCustColors = customColors;
  373.                         cc.rgbResult = RGB(gDocument->clearColorR,
  374.                             gDocument->clearColorG,
  375.                             gDocument->clearColorB); 
  376.                         cc.Flags = CC_RGBINIT; 
  377.  
  378.                         if( ChooseColor( &cc ) )
  379.                         {
  380.                             TQ3DrawContextObject drawContext;
  381.                             TQ3ColorARGB q3Color;
  382.                             q3Color.a = 1.0F;
  383.                             gDocument->clearColorR = GetRValue(cc.rgbResult);
  384.                             q3Color.r = (float)gDocument->clearColorR/(float)255;
  385.                             gDocument->clearColorG = GetGValue(cc.rgbResult);
  386.                             q3Color.g = (float)gDocument->clearColorG/(float)255;
  387.                             gDocument->clearColorB = GetBValue(cc.rgbResult);
  388.                             q3Color.b = (float)gDocument->clearColorB/(float)255;
  389.                             if( gDocument->fView )
  390.                                 if( Q3View_GetDrawContext(gDocument->fView, &drawContext) )
  391.                                     Q3DrawContext_SetClearImageColor(drawContext, &q3Color); 
  392.                             UpdateFrame((BOOLEAN)(kQ3True == gDocument->spin));    
  393.                         }
  394.                         break;
  395.                         }
  396.                     default:
  397.                         return (DefWindowProc(hWnd, message, uParam, lParam));
  398.                 }
  399.                 break;
  400.  
  401.             case WM_CREATE:
  402.                 aStatus = Q3Initialize();
  403.                 if( aStatus == kQ3Failure )
  404.                     return -1;
  405.                 Q3Error_Register( MyErrorHandler, REFERROR );
  406.                 Q3Warning_Register( MyErrorHandler, REFWARNING );
  407.                 Q3Notice_Register( MyErrorHandler, REFNOTICE );
  408.                 gDocument = (DocumentPtr)malloc(sizeof(DocumentRec));
  409.                 memset( gDocument, 0, sizeof(DocumentRec) );
  410.  
  411.                 /* these are the defaults */
  412.                 gDocument->rendererType = kQ3RendererTypeInteractive;
  413.                 gDocument->drawcontextType = kQ3DrawContextTypeWin32DC;
  414.                 gDocument->spin = kQ3True;
  415.                 gDocument->clearColorR = 255;
  416.                 gDocument->clearColorG = 255;
  417.                 gDocument->clearColorB = 255;
  418.  
  419.                 if( InitDocumentData(gDocument, hWnd) == FALSE )
  420.                     return -1;
  421.                 break;
  422.  
  423.             case WM_DESTROY:  // message: window being destroyed
  424.                 PostQuitMessage(0);
  425.                 DisposeDocumentData(gDocument);
  426.                 if( gDocument )
  427.                     free(gDocument);
  428.                 gDocument = NULL;
  429.                 aStatus = Q3Exit();
  430.                 break;
  431.  
  432.             case WM_PAINT:
  433.                 BeginPaint(gDocument->fWindow, &PaintStruct);                
  434.                 DocumentDraw3DData(gDocument);
  435.                 EndPaint(gDocument->fWindow, &PaintStruct);
  436.                 break;
  437.  
  438.             case WM_INITMENU:
  439.                 InitQD3DMenu(hWnd);
  440.                 break;
  441.  
  442.             case WM_SIZE:
  443.                 {
  444.                 unsigned long width = LOWORD(lParam);  // width of client area 
  445.                 unsigned long height = HIWORD(lParam); // height of client area 
  446.  
  447.                 DocumentNewWindowSize( gDocument, width, height );
  448.                 break;
  449.                 }
  450.             default:          // Passes it on if unproccessed
  451.                     return (DefWindowProc(hWnd, message, uParam, lParam));
  452.         }
  453.         return (0);
  454. }
  455.  
  456. void InitQD3DMenu ( HWND hwnd )
  457. {
  458.     HMENU hMenu;
  459.     if( NULL == gDocument )
  460.         return;
  461.  
  462.     hMenu = GetMenu( hwnd );
  463.     if (kQ3True == gDocument->spin) 
  464.         CheckMenuItem( hMenu, ID_QD3D_SPIN, MF_BYCOMMAND | MF_CHECKED );
  465.     else
  466.         CheckMenuItem( hMenu, ID_QD3D_SPIN, MF_BYCOMMAND | MF_UNCHECKED );
  467.  
  468.     if (kQ3RendererTypeInteractive == gDocument->rendererType) 
  469.         CheckMenuItem( hMenu, ID_QD3D_RENDERER_INTERACTIVE, MF_BYCOMMAND | MF_CHECKED );
  470.     else
  471.         CheckMenuItem( hMenu, ID_QD3D_RENDERER_INTERACTIVE, MF_BYCOMMAND | MF_UNCHECKED );
  472.     
  473.     if (kQ3RendererTypeWireFrame == gDocument->rendererType) 
  474.         CheckMenuItem( hMenu, ID_QD3D_RENDERER_WIREFRAME, MF_BYCOMMAND | MF_CHECKED );
  475.     else
  476.         CheckMenuItem( hMenu, ID_QD3D_RENDERER_WIREFRAME, MF_BYCOMMAND | MF_UNCHECKED );
  477.  
  478.     if (kQ3DrawContextTypePixmap == gDocument->drawcontextType)
  479.         switch( gDocument->fPixelFormat )
  480.         {
  481.             case kQ3PixelTypeRGB16:
  482.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP16BIT555, MF_BYCOMMAND | MF_CHECKED );
  483.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP16BIT565, MF_BYCOMMAND | MF_UNCHECKED );
  484.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP24BIT, MF_BYCOMMAND | MF_UNCHECKED );
  485.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP32BIT, MF_BYCOMMAND | MF_UNCHECKED );
  486.                 break;
  487.             case kQ3PixelTypeRGB16_565:
  488.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP16BIT555, MF_BYCOMMAND | MF_UNCHECKED );
  489.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP16BIT565, MF_BYCOMMAND | MF_CHECKED );
  490.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP24BIT, MF_BYCOMMAND | MF_UNCHECKED );
  491.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP32BIT, MF_BYCOMMAND | MF_UNCHECKED );
  492.                 break;
  493.             case kQ3PixelTypeRGB24:
  494.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP16BIT555, MF_BYCOMMAND | MF_UNCHECKED );
  495.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP16BIT565, MF_BYCOMMAND | MF_UNCHECKED );
  496.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP24BIT, MF_BYCOMMAND | MF_CHECKED );
  497.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP32BIT, MF_BYCOMMAND | MF_UNCHECKED );
  498.                 break;
  499.             case kQ3PixelTypeRGB32:
  500.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP16BIT555, MF_BYCOMMAND | MF_UNCHECKED );
  501.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP16BIT565, MF_BYCOMMAND | MF_UNCHECKED );
  502.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP24BIT, MF_BYCOMMAND | MF_UNCHECKED );
  503.                 CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP32BIT, MF_BYCOMMAND | MF_CHECKED );
  504.                 break;
  505.         }
  506.     else
  507.     {
  508.         CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP16BIT555, MF_BYCOMMAND | MF_UNCHECKED );
  509.         CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP16BIT565, MF_BYCOMMAND | MF_UNCHECKED );
  510.         CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP24BIT, MF_BYCOMMAND | MF_UNCHECKED );
  511.         CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_PIXMAP32BIT, MF_BYCOMMAND | MF_UNCHECKED );
  512.     }
  513.  
  514.     if (kQ3DrawContextTypeWin32DC == gDocument->drawcontextType) 
  515.         CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_WIN32DC, MF_BYCOMMAND | MF_CHECKED );
  516.     else
  517.         CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_WIN32DC, MF_BYCOMMAND | MF_UNCHECKED );
  518.  
  519.     if (kQ3DrawContextTypeDDSurface == gDocument->drawcontextType) 
  520.         CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_DIRECTDRAW, MF_BYCOMMAND | MF_CHECKED );
  521.     else
  522.         CheckMenuItem( hMenu, ID_QD3D_DRAWCONTEXT_DIRECTDRAW, MF_BYCOMMAND | MF_UNCHECKED );
  523.     
  524. }
  525.  
  526.  
  527. void MyErrorHandler(TQ3Error firstError, TQ3Error lastError, long refCon) 
  528. { 
  529.     char buf[512];
  530.     switch( refCon )
  531.     {
  532.         case REFERROR:
  533.             sprintf(buf, "QD3D ERROR %d\n", lastError); 
  534.             break;
  535.         case REFWARNING:
  536.             sprintf(buf, "QD3D WARNING %d\n", lastError); 
  537.             break;
  538.         case REFNOTICE:
  539.             sprintf(buf, "QD3D NOTICE %d\n", lastError); 
  540.             break;
  541.     }
  542.     OutputDebugString(buf); 
  543. }
  544.  
  545. char ExtFilter[] = "QuickDraw 3D Metafiles\0*.3dmf;*.3dm;*.q3d;*.qd3d\0All Files\0*.*\0\0";
  546.  
  547. // put up common dialog; fOpen == TRUE for Open, FALSE for Save As.
  548. TQ3Status    BrowseForPathName(char *inPathName, BOOLEAN fOpen) 
  549. {
  550.     OPENFILENAME aFileName;
  551.     TQ3Status     aStatus = kQ3Success;
  552.  
  553.     inPathName[0] = 0;
  554.     aFileName.lStructSize = sizeof(OPENFILENAME);
  555.     aFileName.hwndOwner = gDocument->fWindow;
  556.     aFileName.hInstance = NULL;
  557.     aFileName.lpstrFilter = ExtFilter;
  558.     aFileName.lpstrCustomFilter = NULL; 
  559.     aFileName.nMaxCustFilter = 0L; 
  560.     aFileName.nFilterIndex = 0; 
  561.     aFileName.lpstrFile = inPathName; 
  562.     aFileName.nMaxFile = 255; 
  563.     aFileName.lpstrFileTitle = NULL;    
  564.     aFileName.nMaxFileTitle = 0; 
  565.     aFileName.lpstrInitialDir = NULL;  
  566.     aFileName.lpstrTitle = NULL;    
  567.     aFileName.Flags = OFN_EXPLORER + OFN_LONGNAMES + OFN_PATHMUSTEXIST; 
  568.     if( fOpen )
  569.         aFileName.Flags += OFN_FILEMUSTEXIST;
  570.     aFileName.nFileOffset = 0; 
  571.     aFileName.nFileExtension = 0; 
  572.     aFileName.lpstrDefExt = NULL; 
  573.     aFileName.lCustData = 0; 
  574.     aFileName.lpfnHook = NULL; 
  575.     aFileName.lpTemplateName = NULL; 
  576.     if (fOpen )
  577.         if (GetOpenFileName((LPOPENFILENAME)&aFileName))
  578.             aStatus = kQ3Success;
  579.         else
  580.             aStatus = kQ3Failure;
  581.     else //saving
  582.         if (GetSaveFileName((LPOPENFILENAME)&aFileName))
  583.             aStatus = kQ3Success;
  584.         else
  585.             aStatus = kQ3Failure;
  586.  
  587.     return aStatus;
  588. }
  589.  
  590. /* Note: OpenModelFile will use different storage classes based on storageMethod flag */
  591. void        OpenModelFile( tStorageMethod storageMethod )
  592. {
  593.     #undef A3Assert
  594.     #define    A3Assert(x)        if (!(x)) goto ExitOpenModelFile
  595.  
  596.     char                pathName[MAX_PATH];
  597.     TQ3StorageObject    srcStorage = NULL;
  598.     TQ3FileObject        srcFileObject = NULL;
  599.     TQ3GroupObject        aGroup = NULL;
  600.     TQ3Object            anObject = NULL;
  601.     TQ3FileMode            srcFileMode;
  602.     TQ3GroupPosition    aPosition;
  603.     HANDLE                hFile;
  604.     TQ3Status            aStatus;
  605.     RECT                aWinRect;
  606.     BOOL                aBoolResult;
  607.     DWORD                dwFileSize;
  608.     HANDLE                hFileMap;
  609.     LPVOID                buffer;
  610.     FILE                *aFile;
  611.  
  612.  
  613.     if (BrowseForPathName(pathName, TRUE) != kQ3Success)
  614.         goto ExitOpenModelFile;
  615.     
  616.     /* Open the file and create QD3D storage object */
  617.     switch( storageMethod )
  618.     {
  619.     case kStorageWin32Handle:
  620.     // Use Win32 Handle File Types 
  621.         hFile = CreateFile(
  622.             pathName,    // pointer to name of the file 
  623.             GENERIC_READ,    // access (read-write) mode 
  624.             0,    // share mode 
  625.             NULL,    // pointer to security descriptor 
  626.             OPEN_EXISTING,    // how to create 
  627.             FILE_ATTRIBUTE_NORMAL,    // file attributes 
  628.             NULL     // handle to file with attributes to copy  
  629.         );
  630.         A3Assert(hFile != INVALID_HANDLE_VALUE);
  631.         A3Assert((srcStorage = Q3Win32Storage_New(hFile)) != NULL);
  632.         break;
  633.  
  634.     case kStorageWin32MMFile:
  635.     // Use Win32's Memory Mapped File mechanism to read 3DMF file as 
  636.     // QD3D Memory Buffer Storage Object
  637.         hFile = CreateFile(
  638.             pathName,    // pointer to name of the file 
  639.             GENERIC_READ,    // access (read-write) mode 
  640.             0,    // share mode 
  641.             NULL,    // pointer to security descriptor 
  642.             OPEN_EXISTING,    // how to create 
  643.             FILE_ATTRIBUTE_NORMAL,    // file attributes 
  644.             NULL     // handle to file with attributes to copy  
  645.         );
  646.         A3Assert(hFile != INVALID_HANDLE_VALUE);
  647.         // Create memory mapping of file
  648.         dwFileSize = GetFileSize(hFile, NULL);
  649.         // Create the file-mapping object. 
  650.         hFileMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, dwFileSize, NULL);
  651.         if (hFileMap == NULL) 
  652.         {
  653.           CloseHandle(hFile);
  654.           A3Assert(0);
  655.         }
  656.         // Get the address where the first byte of the file is mapped into memory.
  657.         buffer = MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, 0);
  658.         if (buffer == NULL) 
  659.         {
  660.           CloseHandle(hFileMap);
  661.           CloseHandle(hFile);
  662.           A3Assert(0);
  663.         }
  664.         // Create QD3D Memory Buffer storage object
  665.         A3Assert((srcStorage = Q3MemoryStorage_NewBuffer(buffer, dwFileSize, dwFileSize)) != NULL);
  666.         break;
  667.  
  668.     case kStorageUnixFile:
  669.         aFile = fopen(pathName, "rb");
  670.         A3Assert((srcStorage = Q3UnixStorage_New(aFile)) != NULL);
  671.         break;
  672.     case kStorageUnixPath:
  673.         A3Assert((srcStorage = Q3UnixPathStorage_New(pathName)) != NULL);
  674.         break;
  675.     }
  676.  
  677.     A3Assert((srcFileObject = Q3File_New()) != NULL);
  678.     A3Assert((aStatus = Q3File_SetStorage(srcFileObject, srcStorage)) == kQ3Success);
  679.     A3Assert((aStatus = Q3File_OpenRead(srcFileObject, &srcFileMode)) == kQ3Success);
  680.     A3Assert((aGroup = Q3DisplayGroup_New()) != NULL);
  681.     while (Q3File_IsEndOfFile(srcFileObject) == kQ3False)
  682.     {
  683.         A3Assert((anObject = Q3File_ReadObject(srcFileObject)) != NULL);
  684.         A3Assert(Q3Error_Get(NULL) == kQ3ErrorNone);
  685.         if (Q3Object_IsDrawable(anObject) == kQ3True)
  686.             A3Assert((aPosition = Q3Group_AddObject(aGroup, anObject)) != NULL);
  687.         A3Assert(Q3Object_Dispose(anObject) == kQ3Success);
  688.         anObject = NULL;
  689.     }
  690.     A3Assert((Q3Object_Dispose(gDocument->fModel)) == kQ3Success);
  691.     gDocument->fModel = aGroup;
  692.     A3Assert((aStatus = Q3File_Close(srcFileObject)) == kQ3Success);
  693.     
  694.     /* Close the file system file as needed */
  695.     switch( storageMethod )
  696.     {
  697.     case kStorageWin32Handle:
  698.         CloseHandle( hFile );
  699.         break;
  700.     case kStorageWin32MMFile:
  701.         UnmapViewOfFile( buffer );
  702.         CloseHandle(hFileMap);
  703.         CloseHandle( hFile );
  704.         break;
  705.     case kStorageUnixFile:
  706.         fclose(aFile);
  707.         break;
  708.     case kStorageUnixPath:
  709.         // Nothing extra needs to be done 
  710.         break;
  711.     }
  712.  
  713.     A3Assert((aStatus = Q3Object_Dispose(srcFileObject)) == kQ3Success);
  714.     A3Assert((aStatus = Q3Object_Dispose(srcStorage)) == kQ3Success);
  715.     pvCamera_Fit(gDocument);
  716.     aBoolResult = GetClientRect(gDocument->fWindow, (LPRECT)&aWinRect);
  717.     aBoolResult = InvalidateRect(gDocument->fWindow, &aWinRect, FALSE);    
  718.  
  719. ExitOpenModelFile:
  720.     ;
  721. }
  722.  
  723.  
  724. /* Note: SaveModelFile will use different storage classes based on storageMethod flag */
  725. /* kStorageWin32MMFile is not supported */
  726. void        SaveModelFile( tStorageMethod storageMethod, TQ3FileMode dstFileMode )
  727. {
  728.     #undef A3Assert
  729.     #define    A3Assert(x)        if (!(x)) goto ExitSaveModelFile
  730.  
  731.     char                pathName[MAX_PATH];
  732.     TQ3FileObject        dstFileObject = NULL;
  733.     TQ3StorageObject    dstStorage = NULL;
  734.     TQ3ViewObject        dstView;
  735.     TQ3Status            aStatus;
  736.     TQ3ViewStatus        aViewStatus;
  737.     HANDLE                hFile;
  738.     FILE                *aFile;
  739.  
  740.     if (BrowseForPathName(pathName, FALSE) != kQ3Success)
  741.         goto ExitSaveModelFile;
  742.     
  743.     /* Open the file and create QD3D storage object */
  744.     switch( storageMethod )
  745.     {
  746.     case kStorageWin32Handle:
  747.     // Use Win32 Handle File Types 
  748.         hFile = CreateFile(
  749.             pathName,    // pointer to name of the file 
  750.             GENERIC_WRITE,    // access (read-write) mode 
  751.             0,    // share mode 
  752.             NULL,    // pointer to security descriptor 
  753.             CREATE_NEW,    // how to create 
  754.             FILE_ATTRIBUTE_NORMAL,    // file attributes 
  755.             NULL     // handle to file with attributes to copy  
  756.         );
  757.         A3Assert(hFile != INVALID_HANDLE_VALUE);
  758.         A3Assert((dstStorage = Q3Win32Storage_New(hFile)) != NULL);
  759.         break;
  760.  
  761.     case kStorageWin32MMFile:
  762.         A3Assert(0);    // not supported in this sample
  763.         break;
  764.  
  765.     case kStorageUnixFile:
  766.         if( dstFileMode == kQ3FileModeText )
  767.             aFile = fopen(pathName, "wt"); 
  768.         else
  769.             aFile = fopen(pathName, "wb"); 
  770.         A3Assert((dstStorage = Q3UnixStorage_New(aFile)) != NULL);
  771.         break;
  772.  
  773.     case kStorageUnixPath:
  774.         A3Assert((dstStorage = Q3UnixPathStorage_New(pathName)) != NULL);
  775.         break;
  776.     }
  777.  
  778.  
  779.     A3Assert((dstFileObject = Q3File_New()) != NULL);
  780.     A3Assert((aStatus = Q3File_SetStorage(dstFileObject, dstStorage)) == kQ3Success);
  781.     A3Assert((dstView = Q3View_New()) != NULL);
  782.     A3Assert((aStatus = Q3File_OpenWrite(dstFileObject, dstFileMode)) == kQ3Success);
  783.     A3Assert((aStatus = Q3View_StartWriting(dstView, dstFileObject)) == kQ3Success);
  784.     do
  785.     {
  786.         A3Assert((aStatus = Q3Object_Submit(gDocument->fModel, dstView)) == kQ3Success);
  787.         A3Assert((aViewStatus = Q3View_EndWriting(dstView)) != kQ3ViewStatusError);
  788.     } while (aViewStatus == kQ3ViewStatusRetraverse);
  789.     A3Assert((aStatus = Q3File_Close(dstFileObject)) == kQ3Success);
  790.  
  791.     /* Close the file system file as needed */
  792.     switch( storageMethod )
  793.     {
  794.     case kStorageWin32Handle:
  795.         CloseHandle( hFile );
  796.         break;
  797.     case kStorageWin32MMFile:
  798.         A3Assert(0); //unsupported in this sample
  799.         break;
  800.     case kStorageUnixFile:
  801.         fclose(aFile);
  802.         break;
  803.     case kStorageUnixPath:
  804.         // Nothing extra needs to be done 
  805.         break;
  806.     }
  807.  
  808.     A3Assert((aStatus = Q3Object_Dispose(dstFileObject)) == kQ3Success);
  809.     A3Assert((aStatus = Q3Object_Dispose(dstStorage)) == kQ3Success);
  810.  
  811. ExitSaveModelFile:
  812.     ;
  813. }
  814.  
  815.  
  816.  
  817. BOOL CenterWindow (HWND hwndChild, HWND hwndParent)
  818. {
  819.         RECT    rChild, rParent;
  820.         int     wChild, hChild, wParent, hParent;
  821.         int     wScreen, hScreen, xNew, yNew;
  822.         HDC     hdc;
  823.  
  824.         // Get the Height and Width of the child window
  825.         GetWindowRect (hwndChild, &rChild);
  826.         wChild = rChild.right - rChild.left;
  827.         hChild = rChild.bottom - rChild.top;
  828.  
  829.         // Get the Height and Width of the parent window
  830.         GetWindowRect (hwndParent, &rParent);
  831.         wParent = rParent.right - rParent.left;
  832.         hParent = rParent.bottom - rParent.top;
  833.  
  834.         // Get the display limits
  835.         hdc = GetDC (hwndChild);
  836.         wScreen = GetDeviceCaps (hdc, HORZRES);
  837.         hScreen = GetDeviceCaps (hdc, VERTRES);
  838.         ReleaseDC (hwndChild, hdc);
  839.  
  840.         // Calculate new X position, then adjust for screen
  841.         xNew = rParent.left + ((wParent - wChild) /2);
  842.         if (xNew < 0) {
  843.                 xNew = 0;
  844.         } else if ((xNew+wChild) > wScreen) {
  845.                 xNew = wScreen - wChild;
  846.         }
  847.  
  848.         // Calculate new Y position, then adjust for screen
  849.         yNew = rParent.top  + ((hParent - hChild) /2);
  850.         if (yNew < 0) {
  851.                 yNew = 0;
  852.         } else if ((yNew+hChild) > hScreen) {
  853.                 yNew = hScreen - hChild;
  854.         }
  855.  
  856.         // Set it, and return
  857.         return SetWindowPos (hwndChild, NULL,
  858.                 xNew, yNew, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
  859. }
  860.  
  861.  
  862. // About box callback
  863. LRESULT CALLBACK About(
  864.                 HWND hDlg,           // window handle of the dialog box
  865.                 UINT message,        // type of message
  866.                 WPARAM uParam,       // message-specific information
  867.                 LPARAM lParam)
  868. {
  869.         static  HFONT hfontDlg;
  870.         LPSTR   lpVersion;
  871.         DWORD   dwVerInfoSize;
  872.         DWORD   dwVerHnd;
  873.         UINT    uVersionLen;
  874.         WORD    wRootLen;
  875.         BOOL    bRetCode;
  876.         int     i;
  877.         char    szFullPath[256];
  878.         char    szResult[256];
  879.         char    szGetName[256];
  880.  
  881.         switch (message) {
  882.                 case WM_INITDIALOG:  // message: initialize dialog box
  883.                         // Center the dialog over the application window
  884.                         CenterWindow (hDlg, GetWindow (hDlg, GW_OWNER));
  885.  
  886.                         // Get version information from the application
  887.                         GetModuleFileName (hInst, szFullPath, sizeof(szFullPath));
  888.                         dwVerInfoSize = GetFileVersionInfoSize(szFullPath, &dwVerHnd);
  889.                         if (dwVerInfoSize) {
  890.                                 // If we were able to get the information, process it:
  891.                                 LPSTR   lpstrVffInfo;
  892.                                 HANDLE  hMem;
  893.                                 hMem = GlobalAlloc(GMEM_MOVEABLE, dwVerInfoSize);
  894.                                 lpstrVffInfo  = GlobalLock(hMem);
  895.                                 GetFileVersionInfo(szFullPath, dwVerHnd, dwVerInfoSize, lpstrVffInfo);
  896.                                 lstrcpy(szGetName, "\\StringFileInfo\\040904e4\\");
  897.                                 wRootLen = lstrlen(szGetName);
  898.  
  899.                                 // Walk through the dialog items that we want to replace:
  900.                                 for (i = IDC_FILEDESCRIPTION; i <= IDC_LEGALTRADEMARKS; i++) {
  901.                                         GetDlgItemText(hDlg, i, szResult, sizeof(szResult));
  902.                                         szGetName[wRootLen] = (char)0;
  903.                                         lstrcat (szGetName, szResult);
  904.                                         uVersionLen   = 0;
  905.                                         lpVersion     = NULL;
  906.                                         bRetCode      =  VerQueryValue((LPVOID)lpstrVffInfo,
  907.                                                 (LPSTR)szGetName,
  908.                                                 (LPVOID)&lpVersion,
  909.                                                 (LPDWORD)&uVersionLen); // For MIPS strictness
  910.  
  911.                                         if ( bRetCode && uVersionLen && lpVersion) {
  912.                                                 // Replace dialog item text with version info
  913.                                                 lstrcpy(szResult, lpVersion);
  914.                                                 SetDlgItemText(hDlg, i, szResult);
  915.                                         }
  916.                                 }
  917.  
  918.                                 GlobalUnlock(hMem);
  919.                                 GlobalFree(hMem);
  920.                         } // if (dwVerInfoSize)
  921.                         return (TRUE);
  922.  
  923.                 case WM_COMMAND:                      // message: received a command
  924.                         if (LOWORD(uParam) == IDOK        // "OK" box selected?
  925.                         || LOWORD(uParam) == IDCANCEL) {  // System menu close command?
  926.                                 EndDialog(hDlg, TRUE);        // Exit the dialog
  927.                                 DeleteObject (hfontDlg);
  928.                                 return (TRUE);
  929.                         }
  930.                         break;
  931.         }
  932.         return (FALSE); // Didn't process the message
  933. }
  934.  
  935.  
  936. BOOL InitDocumentData( DocumentPtr theDocument, HWND inWindow ) 
  937. {
  938.     RECT                aWinRect;
  939.     
  940.     theDocument->fWindow = inWindow;
  941.     (void) GetClientRect(inWindow, (LPRECT)&aWinRect);
  942.     theDocument->fWidth = aWinRect.right - aWinRect.left;
  943.     theDocument->fHeight = aWinRect.bottom - aWinRect.top;
  944.  
  945.     // sets up the 3d data for the scene
  946.     // Create view for QuickDraw 3D
  947.     theDocument->fView = MyNewView( theDocument ) ;
  948.     if( NULL == theDocument->fView )
  949.         return FALSE;
  950.  
  951.     // the main display group
  952.     if( NULL == theDocument->fModel )
  953.         theDocument->fModel = MyNewModel() ;
  954.     if( NULL == theDocument->fModel )
  955.         return FALSE;
  956.     
  957.     pvCamera_Fit(theDocument);
  958.  
  959.     // the drawing styles:
  960.     theDocument->fInterpolation = Q3InterpolationStyle_New(kQ3InterpolationStyleVertex) ;
  961.     if( NULL == theDocument->fInterpolation )
  962.         return FALSE;
  963.  
  964.     theDocument->fBackFacing = Q3BackfacingStyle_New(kQ3BackfacingStyleRemove ) ;
  965.     if( NULL == theDocument->fBackFacing )
  966.         return FALSE;
  967.     
  968.     theDocument->fFillStyle = Q3FillStyle_New(kQ3FillStyleFilled ) ;
  969.     if( NULL == theDocument->fFillStyle )
  970.         return FALSE;
  971.  
  972.     theDocument->fIllumination = Q3PhongIllumination_New();
  973.     if( NULL == theDocument->fIllumination )
  974.         return FALSE;
  975.  
  976.     // set the rotation matrix the identity matrix
  977.     Q3Matrix4x4_SetIdentity(&theDocument->fRotation);
  978.  
  979.     return TRUE;
  980. }
  981.  
  982. void DisposeDocumentData( DocumentPtr theDocument)
  983. {
  984.     if( theDocument == NULL )
  985.         return;
  986.     DisposeRenderingData( theDocument);
  987.     if( theDocument->fModel )
  988.     {
  989.         Q3Object_Dispose(theDocument->fModel) ;                // object in the scene being modelled
  990.         theDocument->fModel = NULL;
  991.     }
  992. }
  993.  
  994. void DisposeRenderingData( DocumentPtr theDocument)
  995. {    
  996.     if( theDocument == NULL )
  997.         return;
  998.     if( theDocument->fView )
  999.         Q3Object_Dispose(theDocument->fView) ;                // the view for the scene
  1000.     if( kQ3DrawContextTypePixmap == theDocument->drawcontextType)
  1001.     {
  1002.         if( NULL != theDocument->fBitmap )
  1003.             DeleteObject(theDocument->fBitmap);
  1004.         if( NULL != theDocument->fMemoryDC ) 
  1005.             DeleteDC(theDocument->fMemoryDC);
  1006.     }
  1007.     if( theDocument->fInterpolation )
  1008.         Q3Object_Dispose(theDocument->fInterpolation) ;        // interpolation style used when rendering
  1009.     if( theDocument->fBackFacing )
  1010.         Q3Object_Dispose(theDocument->fBackFacing) ;        // whether to draw shapes that face away from the camera
  1011.     if( theDocument->fFillStyle )
  1012.         Q3Object_Dispose(theDocument->fFillStyle) ;            // whether drawn as solid filled object or decomposed to components
  1013.     if( theDocument->fIllumination )
  1014.         Q3Object_Dispose(theDocument->fIllumination) ;
  1015. }
  1016.  
  1017. //-----------------------------------------------------------------------------
  1018. // 
  1019.  
  1020. TQ3Status DocumentDraw3DData( DocumentPtr theDocument )
  1021. {
  1022.     int fps;
  1023.     if( kQ3Success == Q3View_StartRendering(theDocument->fView ) )    
  1024.         do {    
  1025.             Q3Shader_Submit( theDocument->fIllumination, theDocument->fView );    
  1026.             Q3Style_Submit( theDocument->fInterpolation, theDocument->fView );    
  1027.             Q3Style_Submit( theDocument->fBackFacing, theDocument->fView );    
  1028.             Q3Style_Submit( theDocument->fFillStyle, theDocument->fView );    
  1029.             Q3MatrixTransform_Submit( &theDocument->fRotation, theDocument->fView );    
  1030.             Q3DisplayGroup_Submit( theDocument->fModel, theDocument->fView );    
  1031.         } while (Q3View_EndRendering(theDocument->fView) == kQ3ViewStatusRetraverse );    
  1032.  
  1033.     /* must manually blit from the pixmap draw context */
  1034.     if( kQ3DrawContextTypePixmap == theDocument->drawcontextType)
  1035.     {
  1036.     RECT            aWinRect;
  1037.     BOOL            aResult;
  1038.     HDC                hdc;
  1039.         aResult = GetClientRect(theDocument->fWindow, (LPRECT)&aWinRect);
  1040.         hdc = GetDC(theDocument->fWindow);
  1041.         BitBlt(hdc, 0, 0, theDocument->fWidth, theDocument->fHeight,    
  1042.                 theDocument->fMemoryDC, 0, 0, SRCCOPY);                    
  1043.         GdiFlush();    
  1044.         ReleaseDC(theDocument->fWindow, hdc);                
  1045.     }
  1046.     
  1047.     fps = Speedometer_ClockFrame();
  1048.  
  1049.     /* display frame rate */
  1050.     if ( GetAsyncKeyState( VK_SHIFT ) )
  1051.     {
  1052.         HDC                hdc;
  1053.         char string[25];
  1054.         sprintf( string, "fps: %i", fps );
  1055.         hdc = GetDC(theDocument->fWindow);
  1056.         TextOut( hdc, 0, 0, string, strlen(string) ); 
  1057.     }
  1058.  
  1059.     return kQ3Success ;
  1060. }
  1061.  
  1062. /* Speedometer_ClockFrame
  1063.  * call this routine once per frame, it will return an averaged frames per second value.
  1064.  
  1065.  */
  1066. int Speedometer_ClockFrame( void )
  1067. {
  1068. #define NUMDELTAS 25
  1069.     DWORD    timeNow;
  1070.     DWORD    aveDelta = 0;
  1071.     static DWORD timePrevious = 0;
  1072.     static DWORD deltas[NUMDELTAS] = { 0 };
  1073.     static int nextDelta = 0;
  1074.     int fps, i;
  1075.  
  1076.  
  1077.     if( 0 == timePrevious  )
  1078.         timePrevious = GetTickCount();
  1079.     timeNow =  GetTickCount();
  1080.     deltas[nextDelta] = (timeNow-timePrevious);
  1081.     
  1082.     nextDelta++;
  1083.     if( nextDelta >= NUMDELTAS )
  1084.         nextDelta = 0;
  1085.     
  1086.     for( i = 0; i < NUMDELTAS; i++ )
  1087.         aveDelta += deltas[i];
  1088.     aveDelta /= NUMDELTAS;
  1089.     
  1090.     if( 0 == aveDelta  )
  1091.         aveDelta = 1;
  1092.  
  1093.     /* calculate frames per second */
  1094.     fps = 1000/aveDelta;
  1095.     
  1096.     timePrevious = timeNow;
  1097.     
  1098.     return fps;
  1099. }
  1100.  
  1101. TQ3Status DocumentNewWindowSize(DocumentPtr theDocument, unsigned long width, unsigned long height)
  1102. {
  1103.     TQ3Status    aStatus;
  1104.  
  1105.     aStatus = MyResizeView( theDocument, width, height);
  1106.  
  1107.     pvCamera_Fit(gDocument);
  1108.     
  1109.     return aStatus;
  1110. }
  1111.  
  1112.